home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_xemacs.idb / usr / freeware / lib / xemacs-20.4 / info / gnus.info-3.z / gnus.info-3
Encoding:
GNU Info File  |  1998-05-21  |  49.1 KB  |  1,331 lines
  1. This is Info file ../info/gnus.info, produced by Makeinfo version 1.68
  2. from the input file gnus.texi.
  3.  
  4.    This file documents Gnus, the GNU Emacs newsreader.
  5.  
  6.    Copyright (C) 1995,96 Free Software Foundation, Inc.
  7.  
  8.    Permission is granted to make and distribute verbatim copies of this
  9. manual provided the copyright notice and this permission notice are
  10. preserved on all copies.
  11.  
  12.    Permission is granted to copy and distribute modified versions of
  13. this manual under the conditions for verbatim copying, provided also
  14. that the entire resulting derived work is distributed under the terms
  15. of a permission notice identical to this one.
  16.  
  17.    Permission is granted to copy and distribute translations of this
  18. manual into another language, under the above conditions for modified
  19. versions.
  20.  
  21. 
  22. File: gnus.info,  Node: Summary Post Commands,  Prev: Summary Mail Commands,  Up: Reply Followup and Post
  23.  
  24. Summary Post Commands
  25. ---------------------
  26.  
  27.    Commands for posting a news article:
  28.  
  29. `S p'
  30. `a'
  31.      Post an article to the current group (`gnus-summary-post-news').
  32.  
  33. `S f'
  34. `f'
  35.      Post a followup to the current article (`gnus-summary-followup').
  36.  
  37. `S F'
  38. `F'
  39.      Post a followup to the current article and include the original
  40.      message (`gnus-summary-followup-with-original').   This command
  41.      uses the process/prefix convention.
  42.  
  43. `S n'
  44.      Post a followup to the current article via news, even if you got
  45.      the message through mail (`gnus-summary-followup-to-mail').
  46.  
  47. `S n'
  48.      Post a followup to the current article via news, even if you got
  49.      the message through mail and include the original message
  50.      (`gnus-summary-followup-to-mail-with-original').  This command uses
  51.      the process/prefix convention.
  52.  
  53. `S o p'
  54.      Forward the current article to a newsgroup
  55.      (`gnus-summary-post-forward').  If given a prefix, include the full
  56.      headers of the forwarded article.
  57.  
  58. `S O p'
  59.      Digest the current series and forward the result to a newsgroup
  60.      (`gnus-uu-digest-mail-forward').  This command uses the
  61.      process/prefix convention.
  62.  
  63. `S u'
  64.      Uuencode a file, split it into parts, and post it as a series
  65.      (`gnus-uu-post-news'). (*note Uuencoding and Posting::.).
  66.  
  67. 
  68. File: gnus.info,  Node: Canceling and Superseding,  Next: Marking Articles,  Prev: Reply Followup and Post,  Up: The Summary Buffer
  69.  
  70. Canceling Articles
  71. ==================
  72.  
  73.    Have you ever written something, and then decided that you really,
  74. really, really wish you hadn't posted that?
  75.  
  76.    Well, you can't cancel mail, but you can cancel posts.
  77.  
  78.    Find the article you wish to cancel (you can only cancel your own
  79. articles, so don't try any funny stuff).  Then press `C' or `S c'
  80. (`gnus-summary-cancel-article').  Your article will be
  81. canceled--machines all over the world will be deleting your article.
  82.  
  83.    Be aware, however, that not all sites honor cancels, so your article
  84. may live on here and there, while most sites will delete the article in
  85. question.
  86.  
  87.    If you discover that you have made some mistakes and want to do some
  88. corrections, you can post a "superseding" article that will replace
  89. your original article.
  90.  
  91.    Go to the original article and press `S s'
  92. (`gnus-summary-supersede-article').  You will be put in a buffer where
  93. you can edit the article all you want before sending it off the usual
  94. way.
  95.  
  96.    The same goes for superseding as for canceling, only more so: Some
  97. sites do not honor superseding.  On those sites, it will appear that you
  98. have posted almost the same article twice.
  99.  
  100.    If you have just posted the article, and change your mind right away,
  101. there is a trick you can use to cancel/supersede the article without
  102. waiting for the article to appear on your site first.  You simply return
  103. to the post buffer (which is called `*sent ...*').  There you will find
  104. the article you just posted, with all the headers intact.  Change the
  105. `Message-ID' header to a `Cancel' or `Supersedes' header by
  106. substituting one of those words for the word `Message-ID'.  Then just
  107. press `C-c C-c' to send the article as you would do normally.  The
  108. previous article will be canceled/superseded.
  109.  
  110.    Just remember, kids: There is no 'c' in 'supersede'.
  111.  
  112. 
  113. File: gnus.info,  Node: Marking Articles,  Next: Limiting,  Prev: Canceling and Superseding,  Up: The Summary Buffer
  114.  
  115. Marking Articles
  116. ================
  117.  
  118.    There are several marks you can set on an article.
  119.  
  120.    You have marks that decide the "readedness" (whoo, neato-keano
  121. neologism ohoy!) of the article.  Alphabetic marks generally mean
  122. "read", while non-alphabetic characters generally mean "unread".
  123.  
  124.    In addition, you also have marks that do not affect readedness.
  125.  
  126. * Menu:
  127.  
  128. * Unread Articles::      Marks for unread articles.
  129. * Read Articles::        Marks for read articles.
  130. * Other Marks::          Marks that do not affect readedness.
  131.  
  132.    There's a plethora of commands for manipulating these marks:
  133.  
  134. * Menu:
  135.  
  136. * Setting Marks::           How to set and remove marks.
  137. * Setting Process Marks::   How to mark articles for later processing.
  138.  
  139. 
  140. File: gnus.info,  Node: Unread Articles,  Next: Read Articles,  Up: Marking Articles
  141.  
  142. Unread Articles
  143. ---------------
  144.  
  145.    The following marks mark articles as (kinda) unread, in one form or
  146. other.
  147.  
  148. `!'
  149.      Marked as ticked (`gnus-ticked-mark').
  150.  
  151.      "Ticked articles" are articles that will remain visible always.  If
  152.      you see an article that you find interesting, or you want to put
  153.      off reading it, or replying to it, until sometime later, you'd
  154.      typically tick it.  However, articles can be expired, so if you
  155.      want to keep an article forever, you'll have to make it persistent
  156.      (*note Persistent Articles::.).
  157.  
  158. `?'
  159.      Marked as dormant (`gnus-dormant-mark').
  160.  
  161.      "Dormant articles" will only appear in the summary buffer if there
  162.      are followups to it.
  163.  
  164. `SPACE'
  165.      Markes as unread (`gnus-unread-mark').
  166.  
  167.      "Unread articles" are articles that haven't been read at all yet.
  168.  
  169. 
  170. File: gnus.info,  Node: Read Articles,  Next: Other Marks,  Prev: Unread Articles,  Up: Marking Articles
  171.  
  172. Read Articles
  173. -------------
  174.  
  175.    All the following marks mark articles as read.
  176.  
  177. `r'
  178.      These are articles that the user has marked as read with the `d'
  179.      command manually, more or less (`gnus-del-mark').
  180.  
  181. `R'
  182.      Articles that have actually been read (`gnus-read-mark').
  183.  
  184. `O'
  185.      Articles that were marked as read in previous sessions and are now
  186.      "old" (`gnus-ancient-mark').
  187.  
  188. `K'
  189.      Marked as killed (`gnus-killed-mark').
  190.  
  191. `X'
  192.      Marked as killed by kill files (`gnus-kill-file-mark').
  193.  
  194. `Y'
  195.      Marked as read by having too low a score (`gnus-low-score-mark').
  196.  
  197. `C'
  198.      Marked as read by a catchup (`gnus-catchup-mark').
  199.  
  200. `G'
  201.      Canceled article (`gnus-canceled-mark')
  202.  
  203. `F'
  204.      SOUPed article (`gnus-souped-mark').  *Note SOUP::.
  205.  
  206. `Q'
  207.      Sparsely reffed article (`gnus-sparse-mark').  *Note Customizing
  208.      Threading::.
  209.  
  210. `M'
  211.      Article marked as read by duplicate suppression
  212.      (`gnus-duplicated-mark').  *Note Duplicate Suppression::.
  213.  
  214.    All these marks just mean that the article is marked as read, really.
  215. They are interpreted differently when doing adaptive scoring, though.
  216.  
  217.    One more special mark, though:
  218.  
  219. `E'
  220.      Marked as expirable (`gnus-expirable-mark').
  221.  
  222.      Marking articles as "expirable" (or have them marked as such
  223.      automatically) doesn't make much sense in normal groups--a user
  224.      doesn't control expiring of news articles, but in mail groups, for
  225.      instance, articles marked as "expirable" can be deleted by Gnus at
  226.      any time.
  227.  
  228. 
  229. File: gnus.info,  Node: Other Marks,  Next: Setting Marks,  Prev: Read Articles,  Up: Marking Articles
  230.  
  231. Other Marks
  232. -----------
  233.  
  234.    There are some marks that have nothing to do with whether the
  235. article is read or not.
  236.  
  237.    * You can set a bookmark in the current article.  Say you are
  238.      reading a long thesis on cats' urinary tracts, and have to go home
  239.      for dinner before you've finished reading the thesis.  You can
  240.      then set a bookmark in the article, and Gnus will jump to this
  241.      bookmark the next time it encounters the article.  *Note Setting
  242.      Marks::
  243.  
  244.    * All articles that you have replied to or made a followup to (i.e.,
  245.      have answered) will be marked with an `A' in the second column
  246.      (`gnus-replied-mark').
  247.  
  248.    * Articles stored in the article cache will be marked with an `*' in
  249.      the second column (`gnus-cached-mark').
  250.  
  251.    * Articles "saved" (in some manner or other; not necessarily
  252.      religiously) are marked with an `S' in the second column
  253.      (`gnus-saved-mark').
  254.  
  255.    * If the `%e' spec is used, the presence of threads or not will be
  256.      marked with `gnus-not-empty-thread-mark' and
  257.      `gnus-empty-thread-mark' in the third column, respectively.
  258.  
  259.    * Finally we have the "process mark" (`gnus-process-mark').  A
  260.      variety of commands react to the presence of the process mark.  For
  261.      instance, `X u' (`gnus-uu-decode-uu') will uudecode and view all
  262.      articles that have been marked with the process mark.  Articles
  263.      marked with the process mark have a `#' in the second column.
  264.  
  265.    You might have noticed that most of these "non-readedness" marks
  266. appear in the second column by default.  So if you have a cached, saved,
  267. replied article that you have process-marked, what will that look like?
  268.  
  269.    Nothing much.  The precedence rules go as follows: process -> cache
  270. -> replied -> saved.  So if the article is in the cache and is replied,
  271. you'll only see the cache mark and not the replied mark.
  272.  
  273. 
  274. File: gnus.info,  Node: Setting Marks,  Next: Setting Process Marks,  Prev: Other Marks,  Up: Marking Articles
  275.  
  276. Setting Marks
  277. -------------
  278.  
  279.    All the marking commands understand the numeric prefix.
  280.  
  281. `M t'
  282. `!'
  283.      Tick the current article (`gnus-summary-tick-article-forward').
  284.  
  285. `M ?'
  286. `?'
  287.      Mark the current article as dormant
  288.      (`gnus-summary-mark-as-dormant').
  289.  
  290. `M d'
  291. `d'
  292.      Mark the current article as read
  293.      (`gnus-summary-mark-as-read-forward').
  294.  
  295. `D'
  296.      Mark the current article as read and move point to the previous
  297.      line (`gnus-summary-mark-as-read-backward').
  298.  
  299. `M k'
  300. `k'
  301.      Mark all articles that have the same subject as the current one as
  302.      read, and then select the next unread article
  303.      (`gnus-summary-kill-same-subject-and-select').
  304.  
  305. `M K'
  306. `C-k'
  307.      Mark all articles that have the same subject as the current one as
  308.      read (`gnus-summary-kill-same-subject').
  309.  
  310. `M C'
  311.      Mark all unread articles as read (`gnus-summary-catchup').
  312.  
  313. `M C-c'
  314.      Mark all articles in the group as read--even the ticked and dormant
  315.      articles (`gnus-summary-catchup-all').
  316.  
  317. `M H'
  318.      Catchup the current group to point
  319.      (`gnus-summary-catchup-to-here').
  320.  
  321. `C-w'
  322.      Mark all articles between point and mark as read
  323.      (`gnus-summary-mark-region-as-read').
  324.  
  325. `M V k'
  326.      Kill all articles with scores below the default score (or below the
  327.      numeric prefix) (`gnus-summary-kill-below').
  328.  
  329. `M c'
  330. `M-u'
  331.      Clear all readedness-marks from the current article
  332.      (`gnus-summary-clear-mark-forward').
  333.  
  334. `M e'
  335. `E'
  336.      Mark the current article as expirable
  337.      (`gnus-summary-mark-as-expirable').
  338.  
  339. `M b'
  340.      Set a bookmark in the current article
  341.      (`gnus-summary-set-bookmark').
  342.  
  343. `M B'
  344.      Remove the bookmark from the current article
  345.      (`gnus-summary-remove-bookmark').
  346.  
  347. `M V c'
  348.      Clear all marks from articles with scores over the default score
  349.      (or over the numeric prefix) (`gnus-summary-clear-above').
  350.  
  351. `M V u'
  352.      Tick all articles with scores over the default score (or over the
  353.      numeric prefix) (`gnus-summary-tick-above').
  354.  
  355. `M V m'
  356.      Prompt for a mark, and mark all articles with scores over the
  357.      default score (or over the numeric prefix) with this mark
  358.      (`gnus-summary-clear-above').
  359.  
  360.    The `gnus-summary-goto-unread' variable controls what action should
  361. be taken after setting a mark.  If non-`nil', point will move to the
  362. next/previous unread article.  If `nil', point will just move one line
  363. up or down.  As a special case, if this variable is `never', all the
  364. marking commands as well as other commands (like `SPACE') will move to
  365. the next article, whether it is unread or not.  The default is `t'.
  366.  
  367. 
  368. File: gnus.info,  Node: Setting Process Marks,  Prev: Setting Marks,  Up: Marking Articles
  369.  
  370. Setting Process Marks
  371. ---------------------
  372.  
  373. `M P p'
  374. `#'
  375.      Mark the current article with the process mark
  376.      (`gnus-summary-mark-as-processable').
  377.  
  378. `M P u'
  379. `M-#'
  380.      Remove the process mark, if any, from the current article
  381.      (`gnus-summary-unmark-as-processable').
  382.  
  383. `M P U'
  384.      Remove the process mark from all articles
  385.      (`gnus-summary-unmark-all-processable').
  386.  
  387. `M P i'
  388.      Invert the list of process marked articles
  389.      (`gnus-uu-invert-processable').
  390.  
  391. `M P R'
  392.      Mark articles by a regular expression (`gnus-uu-mark-by-regexp').
  393.  
  394. `M P r'
  395.      Mark articles in region (`gnus-uu-mark-region').
  396.  
  397. `M P t'
  398.      Mark all articles in the current (sub)thread
  399.      (`gnus-uu-mark-thread').
  400.  
  401. `M P T'
  402.      Unmark all articles in the current (sub)thread
  403.      (`gnus-uu-unmark-thread').
  404.  
  405. `M P v'
  406.      Mark all articles that have a score above the prefix argument
  407.      (`gnus-uu-mark-over').
  408.  
  409. `M P s'
  410.      Mark all articles in the current series (`gnus-uu-mark-series').
  411.  
  412. `M P S'
  413.      Mark all series that have already had some articles marked
  414.      (`gnus-uu-mark-sparse').
  415.  
  416. `M P a'
  417.      Mark all articles in series order (`gnus-uu-mark-series').
  418.  
  419. `M P b'
  420.      Mark all articles in the buffer in the order they appear
  421.      (`gnus-uu-mark-buffer').
  422.  
  423. `M P k'
  424.      Push the current process mark set onto the stack and unmark all
  425.      articles (`gnus-summary-kill-process-mark').
  426.  
  427. `M P y'
  428.      Pop the previous process mark set from the stack and restore it
  429.      (`gnus-summary-yank-process-mark').
  430.  
  431. `M P w'
  432.      Push the current process mark set onto the stack
  433.      (`gnus-summary-save-process-mark').
  434.  
  435. 
  436. File: gnus.info,  Node: Limiting,  Next: Threading,  Prev: Marking Articles,  Up: The Summary Buffer
  437.  
  438. Limiting
  439. ========
  440.  
  441.    It can be convenient to limit the summary buffer to just show some
  442. subset of the articles currently in the group.  The effect most limit
  443. commands have is to remove a few (or many) articles from the summary
  444. buffer.
  445.  
  446. `/ /'
  447. `/ s'
  448.      Limit the summary buffer to articles that match some subject
  449.      (`gnus-summary-limit-to-subject').
  450.  
  451. `/ a'
  452.      Limit the summary buffer to articles that match some author
  453.      (`gnus-summary-limit-to-author').
  454.  
  455. `/ u'
  456. `x'
  457.      Limit the summary buffer to articles not marked as read
  458.      (`gnus-summary-limit-to-unread').  If given a prefix, limit the
  459.      buffer to articles strictly unread.  This means that ticked and
  460.      dormant articles will also be excluded.
  461.  
  462. `/ m'
  463.      Ask for a mark and then limit to all articles that have not been
  464.      marked with that mark (`gnus-summary-limit-to-marks').
  465.  
  466. `/ t'
  467.      Ask for a number and then limit the summary buffer to articles
  468.      older than (or equal to) that number of days
  469.      (`gnus-summary-limit-to-marks').  If given a prefix, limit to
  470.      articles younger than that number of days.
  471.  
  472. `/ n'
  473.      Limit the summary buffer to the current article
  474.      (`gnus-summary-limit-to-articles').  Uses the process/prefix
  475.      convention (*note Process/Prefix::.).
  476.  
  477. `/ w'
  478.      Pop the previous limit off the stack and restore it
  479.      (`gnus-summary-pop-limit').  If given a prefix, pop all limits off
  480.      the stack.
  481.  
  482. `/ v'
  483.      Limit the summary buffer to articles that have a score at or above
  484.      some score (`gnus-summary-limit-to-score').
  485.  
  486. `/ E'
  487. `M S'
  488.      Display all expunged articles
  489.      (`gnus-summary-limit-include-expunged').
  490.  
  491. `/ D'
  492.      Display all dormant articles
  493.      (`gnus-summary-limit-include-dormant').
  494.  
  495. `/ d'
  496.      Hide all dormant articles (`gnus-summary-limit-exclude-dormant').
  497.  
  498. `/ c'
  499.      Hide all dormant articles that have no children
  500.      (`gnus-summary-limit-exclude-childless-dormant').
  501.  
  502. `/ C'
  503.      Mark all excluded unread articles as read
  504.      (`gnus-summary-limit-mark-excluded-as-read').   If given a prefix,
  505.      also mark excluded ticked and dormant articles as read.
  506.  
  507. 
  508. File: gnus.info,  Node: Threading,  Next: Sorting,  Prev: Limiting,  Up: The Summary Buffer
  509.  
  510. Threading
  511. =========
  512.  
  513.    Gnus threads articles by default.  "To thread" is to put responses
  514. to articles directly after the articles they respond to--in a
  515. hierarchical fashion.
  516.  
  517. * Menu:
  518.  
  519. * Customizing Threading::     Variables you can change to affect the threading.
  520. * Thread Commands::           Thread based commands in the summary buffer.
  521.  
  522. 
  523. File: gnus.info,  Node: Customizing Threading,  Next: Thread Commands,  Up: Threading
  524.  
  525. Customizing Threading
  526. ---------------------
  527.  
  528. `gnus-show-threads'
  529.      If this variable is `nil', no threading will be done, and all of
  530.      the rest of the variables here will have no effect.  Turning
  531.      threading off will speed group selection up a bit, but it is sure
  532.      to make reading slower and more awkward.
  533.  
  534. `gnus-fetch-old-headers'
  535.      If non-`nil', Gnus will attempt to build old threads by fetching
  536.      more old headers--headers to articles marked as read.  If you
  537.      would like to display as few summary lines as possible, but still
  538.      connect as many loose threads as possible, you should set this
  539.      variable to `some' or a number.  If you set it to a number, no
  540.      more than that number of extra old headers will be fetched.  In
  541.      either case, fetching old headers only works if the backend you
  542.      are using carries overview files--this would normally be `nntp',
  543.      `nnspool' and `nnml'.  Also remember that if the root of the
  544.      thread has been expired by the server, there's not much Gnus can
  545.      do about that.
  546.  
  547. `gnus-build-sparse-threads'
  548.      Fetching old headers can be slow.  A low-rent similar effect can be
  549.      gotten by setting this variable to `some'.  Gnus will then look at
  550.      the complete `References' headers of all articles and try to string
  551.      together articles that belong in the same thread.  This will leave
  552.      "gaps" in the threading display where Gnus guesses that an article
  553.      is missing from the thread.  (These gaps appear like normal summary
  554.      lines.  If you select a gap, Gnus will try to fetch the article in
  555.      question.)  If this variable is `t', Gnus will display all these
  556.      "gaps" without regard for whether they are useful for completing
  557.      the thread or not.  Finally, if this variable is `more', Gnus
  558.      won't cut off sparse leaf nodes that don't lead anywhere.  This
  559.      variable is `nil' by default.
  560.  
  561. `gnus-summary-gather-subject-limit'
  562.      Loose threads are gathered by comparing subjects of articles.  If
  563.      this variable is `nil', Gnus requires an exact match between the
  564.      subjects of the loose threads before gathering them into one big
  565.      super-thread.  This might be too strict a requirement, what with
  566.      the presence of stupid newsreaders that chop off long subject
  567.      lines.  If you think so, set this variable to, say, 20 to require
  568.      that only the first 20 characters of the subjects have to match.
  569.      If you set this variable to a really low number, you'll find that
  570.      Gnus will gather everything in sight into one thread, which isn't
  571.      very helpful.
  572.  
  573.      If you set this variable to the special value `fuzzy', Gnus will
  574.      use a fuzzy string comparison algorithm on the subjects (*note
  575.      Fuzzy Matching::.).
  576.  
  577. `gnus-simplify-subject-fuzzy-regexp'
  578.      This can either be a regular expression or list of regular
  579.      expressions that match strings that will be removed from subjects
  580.      if fuzzy subject simplification is used.
  581.  
  582. `gnus-simplify-ignored-prefixes'
  583.      If you set `gnus-summary-gather-subject-limit' to something as low
  584.      as 10, you might consider setting this variable to something
  585.      sensible:
  586.  
  587.           (setq gnus-simplify-ignored-prefixes
  588.                 (concat
  589.                  "\\`\\[?\\("
  590.                  (mapconcat
  591.                   'identity
  592.                   '("looking"
  593.                     "wanted" "followup" "summary\\( of\\)?"
  594.                     "help" "query" "problem" "question"
  595.                     "answer" "reference" "announce"
  596.                     "How can I" "How to" "Comparison of"
  597.                     ;; ...
  598.                     )
  599.                   "\\|")
  600.                  "\\)\\s *\\("
  601.                  (mapconcat 'identity
  602.                             '("for" "for reference" "with" "about")
  603.                             "\\|")
  604.                  "\\)?\\]?:?[ \t]*"))
  605.  
  606.      All words that match this regexp will be removed before comparing
  607.      two subjects.
  608.  
  609. `gnus-summary-gather-exclude-subject'
  610.      Since loose thread gathering is done on subjects only, that might
  611.      lead to many false hits, especially with certain common subjects
  612.      like `' and `(none)'.  To make the situation slightly better, you
  613.      can use the regexp `gnus-summary-gather-exclude-subject' to say
  614.      what subjects should be excluded from the gathering process.
  615.      The default is `^ *$\\|^(none)$'.
  616.  
  617. `gnus-summary-thread-gathering-function'
  618.      Gnus gathers threads by looking at `Subject' headers.  This means
  619.      that totally unrelated articles may end up in the same "thread",
  620.      which is confusing.  An alternate approach is to look at all the
  621.      `Message-ID's in all the `References' headers to find matches.
  622.      This will ensure that no gathered threads ever include unrelated
  623.      articles, but it also means that people who have posted with broken
  624.      newsreaders won't be gathered properly.  The choice is
  625.      yours--plague or cholera:
  626.  
  627.     `gnus-gather-threads-by-subject'
  628.           This function is the default gathering function and looks at
  629.           `Subject's exclusively.
  630.  
  631.     `gnus-gather-threads-by-references'
  632.           This function looks at `References' headers exclusively.
  633.  
  634.      If you want to test gathering by `References', you could say
  635.      something like:
  636.  
  637.           (setq gnus-summary-thread-gathering-function
  638.                 'gnus-gather-threads-by-references)
  639.  
  640. `gnus-summary-make-false-root'
  641.      If non-`nil', Gnus will gather all loose subtrees into one big tree
  642.      and create a dummy root at the top.  (Wait a minute.  Root at the
  643.      top?  Yup.)  Loose subtrees occur when the real root has expired,
  644.      or you've read or killed the root in a previous session.
  645.  
  646.      When there is no real root of a thread, Gnus will have to fudge
  647.      something.  This variable says what fudging method Gnus should use.
  648.      There are four possible values:
  649.  
  650.     `adopt'
  651.           Gnus will make the first of the orphaned articles the parent.
  652.           This parent will adopt all the other articles.  The adopted
  653.           articles will be marked as such by pointy brackets (`<>')
  654.           instead of the standard square brackets (`[]').  This is the
  655.           default method.
  656.  
  657.     `dummy'
  658.           Gnus will create a dummy summary line that will pretend to be
  659.           the parent.  This dummy line does not correspond to any real
  660.           article, so selecting it will just select the first real
  661.           article after the dummy article.
  662.           `gnus-summary-dummy-line-format' is used to specify the
  663.           format of the dummy roots.  It accepts only one format spec:
  664.           `S', which is the subject of the article.  *Note Formatting
  665.           Variables::.
  666.  
  667.     `empty'
  668.           Gnus won't actually make any article the parent, but simply
  669.           leave the subject field of all orphans except the first
  670.           empty.  (Actually, it will use `gnus-summary-same-subject' as
  671.           the subject (*note Summary Buffer Format::.).)
  672.  
  673.     `none'
  674.           Don't make any article parent at all.  Just gather the
  675.           threads and display them after one another.
  676.  
  677.     `nil'
  678.           Don't gather loose threads.
  679.  
  680. `gnus-thread-hide-subtree'
  681.      If non-`nil', all threads will be hidden when the summary buffer is
  682.      generated.
  683.  
  684. `gnus-thread-expunge-below'
  685.      All threads that have a total score (as defined by
  686.      `gnus-thread-score-function') less than this number will be
  687.      expunged.  This variable is `nil' by default, which means that no
  688.      threads are expunged.
  689.  
  690. `gnus-thread-hide-killed'
  691.      if you kill a thread and this variable is non-`nil', the subtree
  692.      will be hidden.
  693.  
  694. `gnus-thread-ignore-subject'
  695.      Sometimes somebody changes the subject in the middle of a thread.
  696.      If this variable is non-`nil', the subject change is ignored.  If
  697.      it is `nil', which is the default, a change in the subject will
  698.      result in a new thread.
  699.  
  700. `gnus-thread-indent-level'
  701.      This is a number that says how much each sub-thread should be
  702.      indented.  The default is 4.
  703.  
  704. `gnus-parse-headers-hook'
  705.      Hook run before parsing any headers.  The default value is
  706.      `(gnus-decode-rfc1522)', which means that QPized headers will be
  707.      slightly decoded in a hackish way.  This is likely to change in the
  708.      future when Gnus becomes MIMEified.
  709.  
  710. 
  711. File: gnus.info,  Node: Thread Commands,  Prev: Customizing Threading,  Up: Threading
  712.  
  713. Thread Commands
  714. ---------------
  715.  
  716. `T k'
  717. `M-C-k'
  718.      Mark all articles in the current (sub-)thread as read
  719.      (`gnus-summary-kill-thread').  If the prefix argument is positive,
  720.      remove all marks instead.  If the prefix argument is negative, tick
  721.      articles instead.
  722.  
  723. `T l'
  724. `M-C-l'
  725.      Lower the score of the current (sub-)thread
  726.      (`gnus-summary-lower-thread').
  727.  
  728. `T i'
  729.      Increase the score of the current (sub-)thread
  730.      (`gnus-summary-raise-thread').
  731.  
  732. `T #'
  733.      Set the process mark on the current (sub-)thread
  734.      (`gnus-uu-mark-thread').
  735.  
  736. `T M-#'
  737.      Remove the process mark from the current (sub-)thread
  738.      (`gnus-uu-unmark-thread').
  739.  
  740. `T T'
  741.      Toggle threading (`gnus-summary-toggle-threads').
  742.  
  743. `T s'
  744.      Expose the (sub-)thread hidden under the current article, if any
  745.      (`gnus-summary-show-thread').
  746.  
  747. `T h'
  748.      Hide the current (sub-)thread (`gnus-summary-hide-thread').
  749.  
  750. `T S'
  751.      Expose all hidden threads (`gnus-summary-show-all-threads').
  752.  
  753. `T H'
  754.      Hide all threads (`gnus-summary-hide-all-threads').
  755.  
  756. `T t'
  757.      Re-thread the current article's thread
  758.      (`gnus-summary-rethread-current').  This works even when the
  759.      summary buffer is otherwise unthreaded.
  760.  
  761. `T ^'
  762.      Make the current article the child of the marked (or previous)
  763.      article (`gnus-summary-reparent-thread').
  764.  
  765.    The following commands are thread movement commands.  They all
  766. understand the numeric prefix.
  767.  
  768. `T n'
  769.      Go to the next thread (`gnus-summary-next-thread').
  770.  
  771. `T p'
  772.      Go to the previous thread (`gnus-summary-prev-thread').
  773.  
  774. `T d'
  775.      Descend the thread (`gnus-summary-down-thread').
  776.  
  777. `T u'
  778.      Ascend the thread (`gnus-summary-up-thread').
  779.  
  780. `T o'
  781.      Go to the top of the thread (`gnus-summary-top-thread').
  782.  
  783.    If you ignore subject while threading, you'll naturally end up with
  784. threads that have several different subjects in them.  If you then issue
  785. a command like `T k' (`gnus-summary-kill-thread') you might not wish to
  786. kill the entire thread, but just those parts of the thread that have
  787. the same subject as the current article.  If you like this idea, you
  788. can fiddle with `gnus-thread-operation-ignore-subject'.  If it is
  789. non-`nil' (which it is by default), subjects will be ignored when doing
  790. thread commands.  If this variable is `nil', articles in the same
  791. thread with different subjects will not be included in the operation in
  792. question.  If this variable is `fuzzy', only articles that have
  793. subjects fuzzily equal will be included (*note Fuzzy Matching::.).
  794.  
  795. 
  796. File: gnus.info,  Node: Sorting,  Next: Asynchronous Fetching,  Prev: Threading,  Up: The Summary Buffer
  797.  
  798. Sorting
  799. =======
  800.  
  801.    If you are using a threaded summary display, you can sort the
  802. threads by setting `gnus-thread-sort-functions', which is a list of
  803. functions.  By default, sorting is done on article numbers.  Ready-made
  804. sorting predicate functions include `gnus-thread-sort-by-number',
  805. `gnus-thread-sort-by-author', `gnus-thread-sort-by-subject',
  806. `gnus-thread-sort-by-date', `gnus-thread-sort-by-score', and
  807. `gnus-thread-sort-by-total-score'.
  808.  
  809.    Each function takes two threads and returns non-`nil' if the first
  810. thread should be sorted before the other.  Note that sorting really is
  811. normally done by looking only at the roots of each thread.  If you use
  812. more than one function, the primary sort key should be the last function
  813. in the list.  You should probably always include
  814. `gnus-thread-sort-by-number' in the list of sorting
  815. functions--preferably first.  This will ensure that threads that are
  816. equal with respect to the other sort criteria will be displayed in
  817. ascending article order.
  818.  
  819.    If you would like to sort by score, then by subject, and finally by
  820. number, you could do something like:
  821.  
  822.      (setq gnus-thread-sort-functions
  823.            '(gnus-thread-sort-by-number
  824.              gnus-thread-sort-by-subject
  825.              gnus-thread-sort-by-total-score))
  826.  
  827.    The threads that have highest score will be displayed first in the
  828. summary buffer.  When threads have the same score, they will be sorted
  829. alphabetically.  The threads that have the same score and the same
  830. subject will be sorted by number, which is (normally) the sequence in
  831. which the articles arrived.
  832.  
  833.    If you want to sort by score and then reverse arrival order, you
  834. could say something like:
  835.  
  836.      (setq gnus-thread-sort-functions
  837.            '((lambda (t1 t2)
  838.                (not (gnus-thread-sort-by-number t2 t1)))
  839.              gnus-thread-sort-by-score))
  840.  
  841.    The function in the `gnus-thread-score-function' variable (default
  842. `+') is used for calculating the total score of a thread.  Useful
  843. functions might be `max', `min', or squared means, or whatever tickles
  844. your fancy.
  845.  
  846.    If you are using an unthreaded display for some strange reason or
  847. other, you have to fiddle with the `gnus-article-sort-functions'
  848. variable.  It is very similar to the `gnus-thread-sort-functions',
  849. except that it uses slightly different functions for article
  850. comparison.  Available sorting predicate functions are
  851. `gnus-article-sort-by-number', `gnus-article-sort-by-author',
  852. `gnus-article-sort-by-subject', `gnus-article-sort-by-date', and
  853. `gnus-article-sort-by-score'.
  854.  
  855.    If you want to sort an unthreaded summary display by subject, you
  856. could say something like:
  857.  
  858.      (setq gnus-article-sort-functions
  859.            '(gnus-article-sort-by-number
  860.              gnus-article-sort-by-subject))
  861.  
  862. 
  863. File: gnus.info,  Node: Asynchronous Fetching,  Next: Article Caching,  Prev: Sorting,  Up: The Summary Buffer
  864.  
  865. Asynchronous Article Fetching
  866. =============================
  867.  
  868.    If you read your news from an NNTP server that's far away, the
  869. network latencies may make reading articles a chore.  You have to wait
  870. for a while after pressing `n' to go to the next article before the
  871. article appears.  Why can't Gnus just go ahead and fetch the article
  872. while you are reading the previous one?  Why not, indeed.
  873.  
  874.    First, some caveats.  There are some pitfalls to using asynchronous
  875. article fetching, especially the way Gnus does it.
  876.  
  877.    Let's say you are reading article 1, which is short, and article 2 is
  878. quite long, and you are not interested in reading that.  Gnus does not
  879. know this, so it goes ahead and fetches article 2.  You decide to read
  880. article 3, but since Gnus is in the process of fetching article 2, the
  881. connection is blocked.
  882.  
  883.    To avoid these situations, Gnus will open two (count 'em two)
  884. connections to the server.  Some people may think this isn't a very nice
  885. thing to do, but I don't see any real alternatives.  Setting up that
  886. extra connection takes some time, so Gnus startup will be slower.
  887.  
  888.    Gnus will fetch more articles than you will read.  This will mean
  889. that the link between your machine and the NNTP server will become more
  890. loaded than if you didn't use article pre-fetch.  The server itself will
  891. also become more loaded--both with the extra article requests, and the
  892. extra connection.
  893.  
  894.    Ok, so now you know that you shouldn't really use this thing...
  895. unless you really want to.
  896.  
  897.    Here's how:  Set `gnus-asynchronous' to `t'.  The rest should happen
  898. automatically.
  899.  
  900.    You can control how many articles are to be pre-fetched by setting
  901. `gnus-use-article-prefetch'.  This is 30 by default, which means that
  902. when you read an article in the group, the backend will pre-fetch the
  903. next 30 articles.  If this variable is `t', the backend will pre-fetch
  904. all the articles it can without bound.  If it is `nil', no pre-fetching
  905. will be done.
  906.  
  907.    There are probably some articles that you don't want to
  908. pre-fetch--read articles, for instance.  The
  909. `gnus-async-prefetch-article-p' variable controls whether an article is
  910. to be pre-fetched.  This function should return non-`nil' when the
  911. article in question is to be pre-fetched.  The default is
  912. `gnus-async-read-p', which returns `nil' on read articles.  The
  913. function is called with an article data structure as the only parameter.
  914.  
  915.    If, for instance, you wish to pre-fetch only unread articles shorter
  916. than 100 lines, you could say something like:
  917.  
  918.      (defun my-async-short-unread-p (data)
  919.        "Return non-nil for short, unread articles."
  920.        (and (gnus-data-unread-p data)
  921.             (< (mail-header-lines (gnus-data-header data))
  922.                100)))
  923.      
  924.      (setq gnus-async-prefetch-article-p 'my-async-short-unread-p)
  925.  
  926.    These functions will be called many, many times, so they should
  927. preferably be short and sweet to avoid slowing down Gnus too much.
  928. It's probably a good idea to byte-compile things like this.
  929.  
  930.    Articles have to be removed from the asynch buffer sooner or later.
  931. The `gnus-prefetched-article-deletion-strategy' says when to remove
  932. articles.  This is a list that may contain the following elements:
  933.  
  934. `read'
  935.      Remove articles when they are read.
  936.  
  937. `exit'
  938.      Remove articles when exiting the group.
  939.  
  940.    The default value is `(read exit)'.
  941.  
  942.    If `gnus-use-header-prefetch' is non-`nil', prefetch articles from
  943. the next group.
  944.  
  945. 
  946. File: gnus.info,  Node: Article Caching,  Next: Persistent Articles,  Prev: Asynchronous Fetching,  Up: The Summary Buffer
  947.  
  948. Article Caching
  949. ===============
  950.  
  951.    If you have an *extremely* slow NNTP connection, you may consider
  952. turning article caching on.  Each article will then be stored locally
  953. under your home directory.  As you may surmise, this could potentially
  954. use *huge* amounts of disk space, as well as eat up all your inodes so
  955. fast it will make your head swim.  In vodka.
  956.  
  957.    Used carefully, though, it could be just an easier way to save
  958. articles.
  959.  
  960.    To turn caching on, set `gnus-use-cache' to `t'.  By default, all
  961. articles ticked or marked as dormant will then be copied over to your
  962. local cache (`gnus-cache-directory').  Whether this cache is flat or
  963. hierarchal is controlled by the `gnus-use-long-file-name' variable, as
  964. usual.
  965.  
  966.    When re-selecting a ticked or dormant article, it will be fetched
  967. from the cache instead of from the server.  As articles in your cache
  968. will never expire, this might serve as a method of saving articles
  969. while still keeping them where they belong.  Just mark all articles you
  970. want to save as dormant, and don't worry.
  971.  
  972.    When an article is marked as read, is it removed from the cache.
  973.  
  974.    The entering/removal of articles from the cache is controlled by the
  975. `gnus-cache-enter-articles' and `gnus-cache-remove-articles' variables.
  976. Both are lists of symbols.  The first is `(ticked dormant)' by
  977. default, meaning that ticked and dormant articles will be put in the
  978. cache.  The latter is `(read)' by default, meaning that articles marked
  979. as read are removed from the cache.  Possibly symbols in these two
  980. lists are `ticked', `dormant', `unread' and `read'.
  981.  
  982.    So where does the massive article-fetching and storing come into the
  983. picture?  The `gnus-jog-cache' command will go through all subscribed
  984. newsgroups, request all unread articles, and store them in the cache.
  985. You should only ever, ever ever ever, use this command if 1) your
  986. connection to the NNTP server is really, really, really slow and 2) you
  987. have a really, really, really huge disk.  Seriously.
  988.  
  989.    It is likely that you do not want caching on some groups.  For
  990. instance, if your `nnml' mail is located under your home directory, it
  991. makes no sense to cache it somewhere else under your home directory.
  992. Unless you feel that it's neat to use twice as much space.  To limit
  993. the caching, you could set the `gnus-uncacheable-groups' regexp to
  994. `^nnml', for instance.  This variable is `nil' by default.
  995.  
  996.    The cache stores information on what articles it contains in its
  997. active file (`gnus-cache-active-file').  If this file (or any other
  998. parts of the cache) becomes all messed up for some reason or other, Gnus
  999. offers two functions that will try to set things right.  `M-x
  1000. gnus-cache-generate-nov-databases' will (re)build all the NOV files,
  1001. and `gnus-cache-generate-active' will (re)generate the active file.
  1002.  
  1003. 
  1004. File: gnus.info,  Node: Persistent Articles,  Next: Article Backlog,  Prev: Article Caching,  Up: The Summary Buffer
  1005.  
  1006. Persistent Articles
  1007. ===================
  1008.  
  1009.    Closely related to article caching, we have "persistent articles".
  1010. In fact, it's just a different way of looking at caching, and much more
  1011. useful in my opinion.
  1012.  
  1013.    Say you're reading a newsgroup, and you happen on to some valuable
  1014. gem that you want to keep and treasure forever.  You'd normally just
  1015. save it (using one of the many saving commands) in some file.  The
  1016. problem with that is that it's just, well, yucky.  Ideally you'd prefer
  1017. just having the article remain in the group where you found it forever;
  1018. untouched by the expiry going on at the news server.
  1019.  
  1020.    This is what a "persistent article" is--an article that just won't
  1021. be deleted.  It's implemented using the normal cache functions, but you
  1022. use two explicit commands for managing persistent articles:
  1023.  
  1024. `*'
  1025.      Make the current article persistent (`gnus-cache-enter-article').
  1026.  
  1027. `M-*'
  1028.      Remove the current article from the persistent articles
  1029.      (`gnus-cache-remove-article').  This will normally delete the
  1030.      article.
  1031.  
  1032.    Both these commands understand the process/prefix convention.
  1033.  
  1034.    To avoid having all ticked articles (and stuff) entered into the
  1035. cache, you should set `gnus-use-cache' to `passive' if you're just
  1036. interested in persistent articles:
  1037.  
  1038.      (setq gnus-use-cache 'passive)
  1039.  
  1040. 
  1041. File: gnus.info,  Node: Article Backlog,  Next: Saving Articles,  Prev: Persistent Articles,  Up: The Summary Buffer
  1042.  
  1043. Article Backlog
  1044. ===============
  1045.  
  1046.    If you have a slow connection, but the idea of using caching seems
  1047. unappealing to you (and it is, really), you can help the situation some
  1048. by switching on the "backlog".  This is where Gnus will buffer already
  1049. read articles so that it doesn't have to re-fetch articles you've
  1050. already read.  This only helps if you are in the habit of re-selecting
  1051. articles you've recently read, of course.  If you never do that,
  1052. turning the backlog on will slow Gnus down a little bit, and increase
  1053. memory usage some.
  1054.  
  1055.    If you set `gnus-keep-backlog' to a number N, Gnus will store at
  1056. most N old articles in a buffer for later re-fetching.  If this
  1057. variable is non-`nil' and is not a number, Gnus will store *all* read
  1058. articles, which means that your Emacs will grow without bound before
  1059. exploding and taking your machine down with you.  I put that in there
  1060. just to keep y'all on your toes.
  1061.  
  1062.    This variable is `nil' by default.
  1063.  
  1064. 
  1065. File: gnus.info,  Node: Saving Articles,  Next: Decoding Articles,  Prev: Article Backlog,  Up: The Summary Buffer
  1066.  
  1067. Saving Articles
  1068. ===============
  1069.  
  1070.    Gnus can save articles in a number of ways.  Below is the
  1071. documentation for saving articles in a fairly straight-forward fashion
  1072. (i.e., little processing of the article is done before it is saved).
  1073. For a different approach (uudecoding, unsharing) you should use
  1074. `gnus-uu' (*note Decoding Articles::.).
  1075.  
  1076.    If `gnus-save-all-headers' is non-`nil', Gnus will not delete
  1077. unwanted headers before saving the article.
  1078.  
  1079.    If the preceding variable is `nil', all headers that match the
  1080. `gnus-saved-headers' regexp will be kept, while the rest will be
  1081. deleted before saving.
  1082.  
  1083. `O o'
  1084. `o'
  1085.      Save the current article using the default article saver
  1086.      (`gnus-summary-save-article').
  1087.  
  1088. `O m'
  1089.      Save the current article in mail format
  1090.      (`gnus-summary-save-article-mail').
  1091.  
  1092. `O r'
  1093.      Save the current article in rmail format
  1094.      (`gnus-summary-save-article-rmail').
  1095.  
  1096. `O f'
  1097.      Save the current article in plain file format
  1098.      (`gnus-summary-save-article-file').
  1099.  
  1100. `O F'
  1101.      Write the current article in plain file format, overwriting any
  1102.      previous file contents (`gnus-summary-write-article-file').
  1103.  
  1104. `O b'
  1105.      Save the current article body in plain file format
  1106.      (`gnus-summary-save-article-body-file').
  1107.  
  1108. `O h'
  1109.      Save the current article in mh folder format
  1110.      (`gnus-summary-save-article-folder').
  1111.  
  1112. `O v'
  1113.      Save the current article in a VM folder
  1114.      (`gnus-summary-save-article-vm').
  1115.  
  1116. `O p'
  1117.      Save the current article in a pipe.  Uhm, like, what I mean
  1118.      is--Pipe the current article to a process
  1119.      (`gnus-summary-pipe-output').
  1120.  
  1121.    All these commands use the process/prefix convention (*note
  1122. Process/Prefix::.).  If you save bunches of articles using these
  1123. functions, you might get tired of being prompted for files to save each
  1124. and every article in.  The prompting action is controlled by the
  1125. `gnus-prompt-before-saving' variable, which is `always' by default,
  1126. giving you that excessive prompting action you know and loathe.  If you
  1127. set this variable to `t' instead, you'll be prompted just once for each
  1128. series of articles you save.  If you like to really have Gnus do all
  1129. your thinking for you, you can even set this variable to `nil', which
  1130. means that you will never be prompted for files to save articles in.
  1131. Gnus will simply save all the articles in the default files.
  1132.  
  1133.    You can customize the `gnus-default-article-saver' variable to make
  1134. Gnus do what you want it to.  You can use any of the four ready-made
  1135. functions below, or you can create your own.
  1136.  
  1137. `gnus-summary-save-in-rmail'
  1138.      This is the default format, "babyl".  Uses the function in the
  1139.      `gnus-rmail-save-name' variable to get a file name to save the
  1140.      article in.  The default is `gnus-plain-save-name'.
  1141.  
  1142. `gnus-summary-save-in-mail'
  1143.      Save in a Unix mail (mbox) file.  Uses the function in the
  1144.      `gnus-mail-save-name' variable to get a file name to save the
  1145.      article in.  The default is `gnus-plain-save-name'.
  1146.  
  1147. `gnus-summary-save-in-file'
  1148.      Append the article straight to an ordinary file.  Uses the
  1149.      function in the `gnus-file-save-name' variable to get a file name
  1150.      to save the article in.  The default is `gnus-numeric-save-name'.
  1151.  
  1152. `gnus-summary-save-body-in-file'
  1153.      Append the article body to an ordinary file.  Uses the function in
  1154.      the `gnus-file-save-name' variable to get a file name to save the
  1155.      article in.  The default is `gnus-numeric-save-name'.
  1156.  
  1157. `gnus-summary-save-in-folder'
  1158.      Save the article to an MH folder using `rcvstore' from the MH
  1159.      library.  Uses the function in the `gnus-folder-save-name' variable
  1160.      to get a file name to save the article in.  The default is
  1161.      `gnus-folder-save-name', but you can also use
  1162.      `gnus-Folder-save-name', which creates capitalized names.
  1163.  
  1164. `gnus-summary-save-in-vm'
  1165.      Save the article in a VM folder.  You have to have the VM mail
  1166.      reader to use this setting.
  1167.  
  1168.    All of these functions, except for the last one, will save the
  1169. article in the `gnus-article-save-directory', which is initialized from
  1170. the `SAVEDIR' environment variable.  This is `~/News/' by default.
  1171.  
  1172.    As you can see above, the functions use different functions to find a
  1173. suitable name of a file to save the article in.  Below is a list of
  1174. available functions that generate names:
  1175.  
  1176. `gnus-Numeric-save-name'
  1177.      File names like `~/News/Alt.andrea-dworkin/45'.
  1178.  
  1179. `gnus-numeric-save-name'
  1180.      File names like `~/News/alt.andrea-dworkin/45'.
  1181.  
  1182. `gnus-Plain-save-name'
  1183.      File names like `~/News/Alt.andrea-dworkin'.
  1184.  
  1185. `gnus-plain-save-name'
  1186.      File names like `~/News/alt.andrea-dworkin'.
  1187.  
  1188.    You can have Gnus suggest where to save articles by plonking a
  1189. regexp into the `gnus-split-methods' alist.  For instance, if you would
  1190. like to save articles related to Gnus in the file `gnus-stuff', and
  1191. articles related to VM in `vm-stuff', you could set this variable to
  1192. something like:
  1193.  
  1194.      (("^Subject:.*gnus\\|^Newsgroups:.*gnus" "gnus-stuff")
  1195.       ("^Subject:.*vm\\|^Xref:.*vm" "vm-stuff")
  1196.       (my-choosing-function "../other-dir/my-stuff")
  1197.       ((equal gnus-newsgroup-name "mail.misc") "mail-stuff"))
  1198.  
  1199.    We see that this is a list where each element is a list that has two
  1200. elements--the "match" and the "file".  The match can either be a string
  1201. (in which case it is used as a regexp to match on the article head); it
  1202. can be a symbol (which will be called as a function with the group name
  1203. as a parameter); or it can be a list (which will be `eval'ed).  If any
  1204. of these actions have a non-`nil' result, the "file" will be used as a
  1205. default prompt.  In addition, the result of the operation itself will
  1206. be used if the function or form called returns a string or a list of
  1207. strings.
  1208.  
  1209.    You basically end up with a list of file names that might be used
  1210. when saving the current article.  (All "matches" will be used.)  You
  1211. will then be prompted for what you really want to use as a name, with
  1212. file name completion over the results from applying this variable.
  1213.  
  1214.    This variable is `((gnus-article-archive-name))' by default, which
  1215. means that Gnus will look at the articles it saves for an
  1216. `Archive-name' line and use that as a suggestion for the file name.
  1217.  
  1218.    Here's an example function to clean up file names somewhat.  If you
  1219. have lots of mail groups called things like `nnml:mail.whatever', you
  1220. may want to chop off the beginning of these group names before creating
  1221. the file name to save to.  The following will do just that:
  1222.  
  1223.      (defun my-save-name (group)
  1224.        (when (string-match "^nnml:mail." group)
  1225.          (substring group (match-end 0))))
  1226.      
  1227.      (setq gnus-split-methods
  1228.            '((gnus-article-archive-name)
  1229.              (my-save-name)))
  1230.  
  1231.    Finally, you have the `gnus-use-long-file-name' variable.  If it is
  1232. `nil', all the preceding functions will replace all periods (`.') in
  1233. the group names with slashes (`/')--which means that the functions will
  1234. generate hierarchies of directories instead of having all the files in
  1235. the toplevel directory (`~/News/alt/andrea-dworkin' instead of
  1236. `~/News/alt.andrea-dworkin'.)  This variable is `t' by default on most
  1237. systems.  However, for historical reasons, this is `nil' on Xenix and
  1238. usg-unix-v machines by default.
  1239.  
  1240.    This function also affects kill and score file names.  If this
  1241. variable is a list, and the list contains the element `not-score', long
  1242. file names will not be used for score files, if it contains the element
  1243. `not-save', long file names will not be used for saving, and if it
  1244. contains the element `not-kill', long file names will not be used for
  1245. kill files.
  1246.  
  1247.    If you'd like to save articles in a hierarchy that looks something
  1248. like a spool, you could
  1249.  
  1250.      (setq gnus-use-long-file-name '(not-save)) ; to get a hierarchy
  1251.      (setq gnus-default-article-saver 'gnus-summary-save-in-file) ; no encoding
  1252.  
  1253.    Then just save with `o'.  You'd then read this hierarchy with
  1254. ephemeral `nneething' groups--`G D' in the group buffer, and the
  1255. toplevel directory as the argument (`~/News/').  Then just walk around
  1256. to the groups/directories with `nneething'.
  1257.  
  1258. 
  1259. File: gnus.info,  Node: Decoding Articles,  Next: Article Treatment,  Prev: Saving Articles,  Up: The Summary Buffer
  1260.  
  1261. Decoding Articles
  1262. =================
  1263.  
  1264.    Sometime users post articles (or series of articles) that have been
  1265. encoded in some way or other.  Gnus can decode them for you.
  1266.  
  1267. * Menu:
  1268.  
  1269. * Uuencoded Articles::    Uudecode articles.
  1270. * Shared Articles::       Unshar articles.
  1271. * PostScript Files::      Split PostScript.
  1272. * Decoding Variables::    Variables for a happy decoding.
  1273. * Viewing Files::         You want to look at the result of the decoding?
  1274.  
  1275.    All these functions use the process/prefix convention (*note
  1276. Process/Prefix::.) for finding out what articles to work on, with the
  1277. extension that a "single article" means "a single series".  Gnus can
  1278. find out by itself what articles belong to a series, decode all the
  1279. articles and unpack/view/save the resulting file(s).
  1280.  
  1281.    Gnus guesses what articles are in the series according to the
  1282. following simplish rule: The subjects must be (nearly) identical,
  1283. except for the last two numbers of the line.  (Spaces are largely
  1284. ignored, however.)
  1285.  
  1286.    For example: If you choose a subject called `cat.gif (2/3)', Gnus
  1287. will find all the articles that match the regexp `^cat.gif
  1288. ([0-9]+/[0-9]+).*$'.
  1289.  
  1290.    Subjects that are non-standard, like `cat.gif (2/3) Part 6 of a
  1291. series', will not be properly recognized by any of the automatic viewing
  1292. commands, and you have to mark the articles manually with `#'.
  1293.  
  1294. 
  1295. File: gnus.info,  Node: Uuencoded Articles,  Next: Shared Articles,  Up: Decoding Articles
  1296.  
  1297. Uuencoded Articles
  1298. ------------------
  1299.  
  1300. `X u'
  1301.      Uudecodes the current series (`gnus-uu-decode-uu').
  1302.  
  1303. `X U'
  1304.      Uudecodes and saves the current series
  1305.      (`gnus-uu-decode-uu-and-save').
  1306.  
  1307. `X v u'
  1308.      Uudecodes and views the current series (`gnus-uu-decode-uu-view').
  1309.  
  1310. `X v U'
  1311.      Uudecodes, views and saves the current series
  1312.      (`gnus-uu-decode-uu-and-save-view').
  1313.  
  1314.    Remember that these all react to the presence of articles marked with
  1315. the process mark.  If, for instance, you'd like to decode and save an
  1316. entire newsgroup, you'd typically do `M P a' (`gnus-uu-mark-all') and
  1317. then `X U' (`gnus-uu-decode-uu-and-save').
  1318.  
  1319.    All this is very much different from how `gnus-uu' worked with GNUS
  1320. 4.1, where you had explicit keystrokes for everything under the sun.
  1321. This version of `gnus-uu' generally assumes that you mark articles in
  1322. some way (*note Setting Process Marks::.) and then press `X u'.
  1323.  
  1324.    Note: When trying to decode articles that have names matching
  1325. `gnus-uu-notify-files', which is hard-coded to
  1326. `[Cc][Ii][Nn][Dd][Yy][0-9]+.\\(gif\\|jpg\\)', `gnus-uu' will
  1327. automatically post an article on `comp.unix.wizards' saying that you
  1328. have just viewed the file in question.  This feature can't be turned
  1329. off.
  1330.  
  1331.